Comment modifier les messages de commit existants et non poussés?

Modification du message de validation le plus récent
git commit --amend
ouvrira votre éditeur, vous permettant de modifier le message de validation du dernier commit. De plus, vous pouvez définir le message de validation directement dans la ligne de commande avec:
git commit --amend -m "Nouveau message de commit"
… Cependant, cela peut compliquer la saisie des messages de validation sur plusieurs lignes ou de petites corrections.
Assurez-vous qu'aucune modification de copie de travail n'est effectuée avant de faire cela, sinon elles seront également validées. (Les modifications non organisées ne seront pas validées.)
Changer le message d'un commit que vous avez déjà poussé vers votre branche distante
Si vous avez déjà poussé votre validation vers votre branche distante, alors - après avoir modifié votre validation localement (comme décrit ci-dessus) - vous devrez également forcer la transmission avec:
git push   --force
# Ou
git push   -f
Attention: la poussée forcée écrasera la branche distante par l'état de votre branche locale. S'il existe des validations sur la branche distante que vous n'avez pas dans votre branche locale, vous perdrez ces validations.
Attention: soyez prudent lorsque vous modifiez des commits que vous avez déjà partagés avec d'autres personnes. Modifier les commits les réécrit essentiellement pour avoir différents ID SHA, ce qui pose un problème si d'autres personnes ont des copies de l'ancien commit que vous avez réécrit. Quiconque possède une copie de l'ancien commit devra synchroniser son travail avec votre commit nouvellement réécrit, ce qui peut parfois être difficile, alors assurez-vous de vous coordonner avec les autres lorsque vous essayez de réécrire l'historique de commit partagé, ou évitez simplement de réécrire les commits partagés. tout à fait.
Effectuer un rebase interactif
Une autre option consiste à utiliser le rebase interactif.
Cela vous permet de modifier tout message que vous souhaitez mettre à jour même s'il ne s'agit pas du dernier message.
Pour faire un squash Git, procédez comme suit:
// n est le nombre de commits jusqu'au dernier commit que vous voulez pouvoir modifier
git rebase -i HEAD ~ n
Une fois que vous avez écrasé vos validations, choisissez l'e / r pour éditer le message:
Remarque importante sur le rebase interactif
Lorsque vous utilisez git rebase -i HEAD ~ n, il peut y avoir plus de n validations. Git "collectera" tous les commits dans les n derniers commits, et s'il y avait une fusion quelque part entre cette plage, vous verrez également tous les commits, donc le résultat sera n +.
Bon conseil:
Si vous devez le faire pour plus d'une branche et que vous risquez de rencontrer des conflits lors de la modification du contenu, configurez git rerere et laissez Git résoudre ces conflits automatiquement pour vous.
Documentation
Page de manuel git-commit (1)
Page de manuel git-rebase (1)
Page de manuel git-push (1)
|
git commit --amend -m "votre nouveau message"
|
Si le commit que vous souhaitez corriger n'est pas le plus récent:
git rebase --interactive $ parent_of_flawed_commit
Si vous souhaitez corriger plusieurs commits défectueux, transmettez le parent du plus ancien d'entre eux.
Un éditeur apparaîtra, avec une liste de tous les commits depuis celui que vous avez donné.
Changez le choix pour reformuler (ou sur les anciennes versions de Git, pour modifier) ​​devant tous les commits que vous souhaitez corriger.
Une fois que vous avez enregistré, Git rejouera les commits répertoriés.
Pour chaque commit que vous souhaitez reformuler, Git vous ramènera dans votre éditeur. Pour chaque commit que vous souhaitez modifier, Git vous dépose dans le shell. Si vous êtes dans la coquille:
Modifiez le commit comme vous le souhaitez.
git commit --amend
git rebase --continuer
La plupart de cette séquence vous sera expliquée par la sortie des différentes commandes au fur et à mesure. C'est très facile; vous n'avez pas besoin de le mémoriser - rappelez-vous simplement que git rebase --interactive vous permet de corriger les commits, quelle que soit leur ancienneté.
Notez que vous ne voudrez pas modifier les commits que vous avez déjà poussés. Ou peut-être que vous le faites, mais dans ce cas, vous devrez prendre grand soin de communiquer avec tous ceux qui ont pu retirer vos engagements et travailler dessus. Comment récupérer / resynchroniser après que quelqu'un a poussé un rebase ou une réinitialisation dans une branche publiée?
|
Pour modifier la validation précédente, apportez les modifications souhaitées et organisez ces modifications, puis exécutez
git commit --amend
Cela ouvrira un fichier dans votre éditeur de texte représentant votre nouveau message de validation. Il commence par être rempli avec le texte de votre ancien message de validation. Modifiez le message de validation comme vous le souhaitez, puis enregistrez le fichier et quittez votre éditeur pour terminer.
Pour modifier le commit précédent et conserver le même message de journal, exécutez
git commit --amend -C HEAD
Pour corriger le commit précédent en le supprimant entièrement, exécutez
git reset --hard HEAD ^
Si vous souhaitez modifier plus d'un message de validation, exécutez
git rebase -i HEAD ~ commit_count
(Remplacez commit_count par le nombre de commits que vous souhaitez modifier.) Cette commande lance votre éditeur. Marquez le premier commit (celui que vous voulez changer) comme "edit" au lieu de "pick", puis enregistrez et quittez votre éditeur. Apportez la modification que vous souhaitez valider, puis exécutez
git commit --amend
git rebase --continuer
Remarque: vous pouvez également "Apporter la modification souhaitée" à partir de l'éditeur ouvert par git commit --amend
|
Comme déjàmentionné, git commit --amend est le moyen d'écraser le dernier commit. Une note: si vous souhaitez également écraser les fichiers, la commande serait
git commit -a --amend -m "Mon nouveau message de commit"
|
Vous pouvez également utiliser git filter-branch pour cela.
git filter-branch -f --msg-filter "sed 's / errror / error /'" $ flawed_commit..HEAD
Ce n'est pas aussi facile qu'un simple commit git --amend, mais c'est particulièrement utile si vous avez déjà des fusions après votre message de commit erroné.
Notez que cela tentera de réécrire chaque commit entre HEAD et le commit défectueux, vous devriez donc choisir votre commande msg-filter très judicieusement ;-)
|
Je préfère cette façon:
git commit --amend -c 
Sinon, il y aura un nouveau commit avec un nouvel ID de commit.
|
Si vous utilisez l'outil GUI Git, il existe un bouton nommé Modifier le dernier commit. Cliquez sur ce bouton et il affichera vos derniers fichiers de validation et message. Modifiez simplement ce message et vous pouvez le valider avec un nouveau message de validation.
Ou utilisez cette commande depuis une console / un terminal:
git commit -a --amend -m "Mon nouveau message de commit"
|
Vous pouvez utiliser le rebasage Git. Par exemple, si vous souhaitez modifier à nouveau pour valider bbc643cd, exécutez
$ git rebase bbc643cd ^ --interactif
Dans l'éditeur par défaut, modifiez 'pick' en 'edit' dans la ligne dont vous voulez modifier le commit. Apportez vos modifications, puis mettez-les en scène avec
$ git add 
Vous pouvez maintenant utiliser
$ git commit --amend
pour modifier le commit, et après cela
$ git rebase --continuer
pour revenir au commit principal précédent.
|
Si vous souhaitez uniquement modifier votre dernier message de validation, procédez comme suit:
git commit --amend
Cela vous déposera dans votre éditeur de texte et vous permettra de modifier le dernier message de validation.
Si vous souhaitez modifier les trois derniers messages de validation, ou l'un des messages de validation jusqu'à ce point, fournissez HEAD ~ 3 à la commande git rebase -i:
git rebase -i HEAD ~ 3
|
Si vous devez modifier un ancien message de validation sur plusieurs branches (c'est-à-dire que la validation avec le message erroné est présente dans plusieurs branches), vous pouvez utiliser:
git filter-branch -f --msg-filter \
'sed "s /  /  / g"' - --all
Git créera un répertoire temporaire pour la réécriture et sauvegardera en plus les anciennes références dans refs / original /.
-f imposera l'exécution de l'opération. Ceci est nécessaire si le répertoire temporaire est déjà présent ou s'il existe déjà des références stockées sous refs / original. Si ce n'est pas le cas, vous pouvez supprimer cet indicateur.
- sépare les options de branche de filtre des options de révision.
--all s'assurera que toutes les branches et balises sont réécrites.
Grâce à la sauvegarde de vos anciennes références, vous pouvez facilement revenir à l'état avant d'exécuter la commande.
Dites, vous voulez récupérer votre maître et y accéder dans la branche old_master:
git checkout -b old_master refs / original / refs / heads / master
|
Utilisation
git commit --amend
Pour le comprendre en détail, un excellent article est 4. Réécrire l'histoire de Git. Il explique également quand ne pas utiliser git commit --amend.
|
Si c'est votre dernier commit, modifiez simplement le commit:
git commit --amend -o -m "Nouveau message de commit"
(Utilisation de l'indicateur -o (--only) pour vous assurer de ne modifier que le message de validation)
S'il s'agit d'un commit enterré, utilisez l'impressionnant rebase interactif:
git rebase -i @ ~ 9 # Afficher les 9 derniers commits dans un éditeur de texte
Trouvez le commit souhaité, remplacez pick par r (reformulation), puis enregistrez et fermez le fichier. Terminé!
Tutoriel miniature Vim (ou, comment rebaser avec seulement 8 touches 3jcwrEscZZ):
Exécutez vimtutor si vous avez le temps
hjkl correspondent aux touches de mouvement ← ↓ ↑ →
Toutes les commandes peuvent être précédées d'une "plage", par ex. 3j descend de trois lignes
i pour entrer en mode insertion - le texte que vous saisissez apparaîtra dans le fichier
Echap ou Ctrlc pour quitter le mode insertion et revenir au mode "normal"
u pour annuler
Ctrlr pour refaire
dd, dw, dl pour supprimer respectivement une ligne, un mot ou une lettre
cc, cw, cl pour changer respectivement une ligne, un mot ou une lettre (identique à ddi)
yy, yw, yl pour copier ("yank") une ligne, un mot ou une lettre, respectivement
p ou P pour coller respectivement après ou avant la position actuelle
: wEntrez pour enregistrer (écrire) un fichier
: q! Entrez pour quitter sans enregistrer
: wqEntrez ou ZZ pour enregistrer et quitter
Si vous modifiez beaucoup de texte, passez à la disposition du clavier Dvorak, apprenez à taper et apprenez Vim. Cela en vaut-il la peine? Oui.
ProTip ™: N'ayez pas peur d'expérimenter des commandes "dangereuses" qui réécrivent l'historique * - Git ne supprime pas vos commits pendant 90 jours par défaut; vous pouvez les trouver dans le reflog:
$ git reset @ ~ 3 # Retourne trois commits
$ git reflog
c4f708b HEAD @ {0}: réinitialisation: passage à @ ~ 3
2c52489 HEAD @ {1}: commit: plus de changements
4a5246d HEAD @ {2}: commit: apporter des modifications importantes
e8571e4 HEAD @ {3}: commit: apporter quelques modifications
... plus tôt commits ...
$ git reset 2c52489
... et vous êtes de retour là où vous avez commencé
* Méfiez-vous des options comme --hard et --force cependant - ils peuvent supprimer des données.
* De plus, ne réécrivez pas l'historique sur les branches sur lesquelles vous collaborez.
|
Modifier
Vous avez quelquesoptions ici. Tu peux faire
git commit --amend
tant que c'est votre dernier commit.
Rebase interactif
Sinon, si ce n'est pas votre dernier commit, vous pouvez faire un rebase interactif,
git rebase -i [branched_from] [hachage avant validation]
Ensuite, à l'intérieur du rebase interactif, vous ajoutez simplement une modification à ce commit. Quand cela arrive, faites un git commit --amend et modifiez le message de commit. Si vous voulez revenir en arrière avant ce point de commit, vous pouvez également utiliser git reflog et simplement supprimer ce commit. Ensuite, vous refaites un commit git.
|
Si vous utilisez l'interface graphique Git, vous pouvez modifier le dernier commit qui n'a pas été poussé avec:
Valider / Modifier la dernière validation
|
J'utilise l'interface graphique Git autant que je peux, et cela vous donne la possibilité de modifier le dernier commit:
De plus, git rebase -i origin / master est un joli mantra qui vous présentera toujours les commits que vous avez effectués au-dessus de master et vous donnera la possibilité de modifier, supprimer, réorganiser ou écraser. Pas besoin de mettre la main sur ce hachage en premier.
|
Wow, il existe donc de nombreuses façons de le faire.
Une autre façon de faire est de supprimer le dernier commit, mais de conserver ses modifications afin de ne pas perdre votre travail. Vous pouvez ensuite faire un autre commit avec le message corrigé. Cela ressemblerait à quelque chose comme ceci:
git reset --soft HEAD ~ 1
git commit -m 'Message de commit nouveau et corrigé'
Je fais toujours cela si j'oublie d'ajouter un fichier ou de faire un changement.
N'oubliez pas de spécifier --soft au lieu de --hard, sinon vous perdez entièrement ce commit.
|
Pour tous ceux qui recherchent une interface graphique Windows / Mac pour aider à modifier les anciens messages (c'est-à-dire pas seulement le dernier message), je recommanderais Sourcetree. Les étapes à suivre se trouvent sous l'image.
Pour les commits qui n'ont pas encore été poussés vers une télécommande:
Assurez-vous que vous avez validé ou caché toutes les modifications actuelles (c'est-à-dire qu'il n'y a pas de fichiers répertoriés dans l'onglet "État du fichier") - cela ne fonctionnera pas autrement.
Dans l'onglet "Journal / Historique", faites un clic droit sur l'entrée avec une ligne adjacente dans le graphique sous le ou les commit (s) que vous souhaitez éditer et sélectionnez "Rebase children of  interactivement ..."
Sélectionnez toute la ligne d'un message de validation que vous souhaitez modifier (cliquez sur la colonne «Message»).
Cliquez sur le bouton "Modifier le message".
Modifiez le message comme vous le souhaitez dans la boîte de dialogue qui s'affiche, puis cliquez sur OK.
Répétez les étapes 3 à 4 s'il existe d'autres messages de validation à modifier.
Cliquez sur OK: la réinitialisation commencera. Si tout va bien, la sortie se terminera par "Terminé avec succès". REMARQUE: j'ai parfois vu cet échec avec Impossible de créer 'project_path / .git / index.lock': le fichier existe. lorsque vous essayez de modifier plusieurs messages de validation en même temps. Je ne sais pas exactement quel est le problème, ou s'il sera résolu dans une future version de Sourcetree, mais si cela se produit, je recommanderais de les rebaser un par un (plus lent mais semble plus fiable).
... Ou ... pour les commits déjà poussés:
Suivez les étapes de cette réponse, qui sont similaires à celles ci-dessus, mais nécessitent une commande supplémentaire à exécuter à partir de la ligne de commande (git push origin  -f) pour forcer la branche. Je recommanderais de tout lire et d'appliquer la prudence nécessaire!
|
Si vous souhaitez simplement modifier le dernier commit, utilisez:
git commit --amend
ou
git commit --amend -m 'message d'une ligne'
Mais si vous souhaitez modifier plusieurs commits à la suite, vous devez utiliser le rebasage à la place:
git rebase -i 
Dans un fichier, comme celui ci-dessus, écrivez edit / e ou l'une des autres options, puis appuyez sur Enregistrer et quitter.
Vous serez maintenant au premier mauvais commit. Apportez des modifications aux fichiers, et ils seront automatiquement mis en scène pour vous. Type
git commit --amend
Enregistrez et quittez et tapez
git rebase --continuer
pour passer à la sélection suivante jusqu'à ce que vous ayez terminé avec toutes vos sélections.
Notez que ces choses changent tous vos hachages SHA après cette validation particulière.
|
Si vous souhaitez uniquement modifier votre dernier message, vous devez utiliser l'indicateur --only ou son raccourci -o avec commit --amend:
git commit --amend -o -m "Nouveau message de commit"
Cela garantit que vous n'améliorez pas accidentellement votre validation avec des éléments mis en scène. Bien sûr, il est préférable d'avoir une configuration $ EDITOR appropriée. Ensuite, vous pouvez laisser l'option -m de côté, et Git pré-remplira le message de validation avec l'ancien. De cette façon, il peut être facilement édité.
|
Mettez à jour votre dernier message de validation erroné avec le nouveau message de validation sur une ligne:
git commit --amend -m "votre nouveau message de commit"
Ou essayez de réinitialiser Git comme ci-dessous:
# Vous pouvez réinitialiser votre tête à n nombre de commit
# PAS une bonne idée pour changer le dernier message de commit,
# mais vous pouvez avoir une idée pour diviser le commit en plusieurs commits
git reset --soft HEAD ^
# Cela réinitialisera votre dernier commit. Maintenant, c'est à votre tour
# peut le re-commit avec un nouveau message de commit.
Utiliser la réinitialisation pour diviser les commits en commits plus petits
git reset peut également vous aider à diviser un commit en plusieurs commits:
# Réinitialisez votre tête. Je réinitialise aux derniers commits:
git reset --soft HEAD ^
# (Vous pouvez réinitialiser plusieurs commit en faisant HEAD ~ 2 (nombre de commits)
# Maintenant, réinitialisez votre tête pourle fractionner en plusieurs commits
git reset HEAD
# Ajoutez et validez vos fichiers séparément pour faire plusieurs commits: par exemple
git ajouter une application /
git commit -m "ajouter tous les fichiers dans le répertoire de l'application"
git add config /
git commit -m "ajoute tous les fichiers dans le répertoire de configuration"
Ici, vous avez réussi à diviser votre dernier commit en deux commits.
|
Sur cette question, il y a beaucoup de réponses, mais aucune d'entre elles n'explique en détail comment modifier les anciens messages de validation en utilisant Vim. J'étais coincé à essayer de le faire moi-même, alors j'écrirai ici en détail comment j'ai fait cela, en particulier pour les personnes qui n'ont aucune expérience de Vim!
Je voulais changer mes cinq derniers commits que j'avais déjà poussés vers le serveur. C'est assez «dangereux» car si quelqu'un d'autre s'en est déjà tiré, vous pouvez tout gâcher en modifiant les messages de validation. Cependant, lorsque vous travaillez sur votre propre petite branche et que vous êtes sûr que personne ne l'a tirée, vous pouvez la changer comme ceci:
Supposons que vous souhaitiez modifier vos cinq derniers commits, puis que vous saisissez ceci dans le terminal:
git rebase -i HEAD ~ 5
* Où 5 est le nombre de messages de commit que vous voulez changer (donc si vous voulez changer le 10e pour le dernier commit, vous tapez 10).
Cette commande vous amènera dans Vim, vous pourrez «modifier» votre historique de validation. Vous verrez vos cinq derniers commits en haut comme ceci:
choisissez  message de validation
Au lieu de choisir, vous devez rédiger une reformulation. Vous pouvez le faire dans Vim en tapant i. Cela vous fait passer en mode insertion. (Vous voyez que vous êtes en mode d'insertion par le mot INSERT en bas.) Pour les commits que vous souhaitez modifier, tapez reformuler au lieu de choisir.
Ensuite, vous devez enregistrer et quitter cet écran. Pour ce faire, passez d'abord en «mode commande» en appuyant sur le bouton Echap (vous pouvez vérifier que vous êtes en mode commande si le mot INSERT en bas a disparu). Ensuite, vous pouvez taper une commande en tapant:. La commande pour enregistrer et quitter est wq. Donc, si vous tapez: wq, vous êtes sur la bonne voie.
Ensuite, Vim passera en revue chaque message de validation que vous souhaitez reformuler, et ici vous pouvez réellement modifier les messages de validation. Vous ferez cela en passant en mode insertion, en modifiant le message de validation, en passant en mode commande, en enregistrant et en quittant. Faites cela cinq fois et vous êtes hors de Vim!
Ensuite, si vous avez déjà poussé vos mauvais commits, vous devez git push --force pour les écraser. Rappelez-vous que git push --force est une chose assez dangereuse à faire, alors assurez-vous que personne ne s'est retiré du serveur depuis que vous avez poussé vos mauvais commits!
Vous avez maintenant changé vos messages de validation!
(Comme vous le voyez, je n'ai pas l'expérience de Vim, donc si j'ai utilisé le mauvais `` jargon '' pour expliquer ce qui se passe, n'hésitez pas à me corriger!)
|
Vous pouvez utiliser git-rebase-reword
Il est conçu pour éditer n'importe quel commit (pas seulement le dernier) de la même manière que commit --amend
$ git rebase-reword 
Il est nommé d'après l'action sur rebase interactive pour modifier un commit: "reword". Voir cet article et la section homme-mode interactif-
Exemples:
$ git rebase-reword b68f560
$ git rebase-reword HEAD ^
|
J'ai ajouté les alias reci et recm pour le réitérer (modifier). Maintenant, je peux le faire avec git recm ou git recm -m:
$ vim ~ / .gitconfig
[alias]
......
cm = commettre
reci = commit --amend
recm = commit --amend
......
|
J'ai réalisé que j'avais poussé un commit avec une faute de frappe dedans. Pour annuler, j'ai fait ce qui suit:
git commit --amend -m "T-1000, prototype avancé"
git push --force
Attention: forcer à pousser vos modifications écrasera la branche distante par la branche locale. Assurez-vous de ne pas écraser tout ce que vous souhaitez conserver. Faites également attention à ne pas forcer à pousser un commit modifié (réécrit) si quelqu'un d'autre partage la branche avec vous, car il devra réécrire son propre historique s'il a l'ancienne copie du commit que vous venez de réécrire.
|
J'aime utiliser ce qui suit:
état git
git add --all
git commit -am "message va ici à propos du changement"
git pull 
git push 
|
Si vous n'avez pas transmis le code à votre branche distante (GitHub / Bitbucket), vous pouvez modifier le message de validation sur la ligne de commande comme ci-dessous.
git commit --amend -m "Votre nouveau message"
Si vous travaillez sur une branche spécifique, procédez comme suit:
git commit --amend -m "BRANCH-NAME: nouveau message"
Si vous avez déjà envoyé le code avec le mauvais message et que vous devez faire attention lorsque vous modifiez le message. Autrement dit, après avoir modifié le message de validation et essayé de le pousser à nouveau, vous vous retrouvez avec des problèmes. Pour le rendre fluide, procédez comme suit.
Veuillez lire toute ma réponse avant de le faire.
git commit --amend -m "BRANCH-NAME: votre nouveau message"
git push -f origin BRANCH-NAME # Ce n'est pas une bonne pratique. Lisez ci-dessous pourquoi?
Remarque importante: lorsque vous utilisez directement la poussée forcée, vous pouvez vous retrouver avec des problèmes de code que d'autres développeurs travaillent sur la même branche. Donc, pour éviter ces conflits, vous devez extraire le code de votre branche avant de forcerpousser:
git commit --amend -m "BRANCH-NAME: votre nouveau message"
git pull origin BRANCH-NAME
git push -f origine BRANCH-NAME
Il s'agit de la meilleure pratique lors de la modification du message de validation, s'il a déjà été envoyé.
|
Ce n'est pas la réponse que vous recherchez? Parcourir les autres questions marquées git git-commit git-rewrite-history modifier ou poser votre propre question.